#include "imagen.h"
#include <QImage>
# include <iostream>
using namespace std;

IplImage* cargarImagen(const char *nombreArchivo, int flag)
{
    return cvLoadImage(nombreArchivo,flag);
}

bool guardarImagen(const char *archivoSalida,IplImage* imagen)
{
    return cvSaveImage(archivoSalida,imagen);
}

/*IplImage* copiaGris(IplImage* img)
{
    IplImage* imgGris;
     cvCvtColor(img,imgGris,CV_BGR2GRAY);
     return imgGris ;
}*/

IplImage* negativo(IplImage* imagen)
{
    IplImage* img=imagen;
    cvNot( img,img);
    return img;
}

IplImage* zoomImagen(IplImage* imagen, int porcentaje)
{
    IplImage* destino;
    destino = cvCreateImage(cvSize((imagen->width*porcentaje)/100,(imagen->height*porcentaje)/100),imagen->depth,imagen->nChannels);
    cvResize(imagen, destino, CV_INTER_AREA);
    return destino;
}

void canalesImagen(IplImage* img, IplImage* a, IplImage* b, IplImage* c)
{
    cvSplit( img, c, b, a, NULL );
}
/*-------------------------------------------------------------------------------------*/

IplImage * obtenerCanal(IplImage *img, int numeroCanal)
{
    IplImage *canal1,*canal2,*canal3;
        canal1= cvCreateImage( cvGetSize(img), 8, 1 );
        canal2= cvCreateImage( cvGetSize(img), 8, 1 );
        canal3= cvCreateImage( cvGetSize(img), 8, 1 );
        cvSplit(img,canal1,canal2,canal3,0);
        if(numeroCanal==1) return canal1;
        if(numeroCanal==2) return canal2;
        if(numeroCanal==3) return canal3;
        else return canal1;
}

string obtenerEspacioColor(IplImage *img)
{
    string espacio;
    espacio.append(img->colorModel);
    return espacio;
}

int cambiarEspacioColor(IplImage* img,string espacio)
{
    string espacioViejo;
    espacioViejo.append(img->colorModel);
    if (espacio==espacioViejo) return 0;
    else
    {
         if (espacioViejo=="RGB")
         {
              if(espacio=="HSV")
              {
                    cvCvtColor(img,img,CV_BGR2HSV);
                    strcpy(img->colorModel,espacio.c_str());
                    return 0;
              }
              if(espacio=="HSL")
              {
                     cvCvtColor(img,img,CV_BGR2HLS);
                     strcpy(img->colorModel,espacio.c_str());
                     return 0;
              }
              else return 1;
          }
          if (espacioViejo=="HSV")
          {
              if(espacio=="RGB")
              {
                      cvCvtColor(img,img,CV_HSV2BGR);
                      strcpy(img->colorModel,espacio.c_str());
                      return 0;
              }
              if(espacio=="HSL")
              {
                      cvCvtColor(img,img,CV_HSV2BGR);
                      cvCvtColor(img,img,CV_BGR2HLS);
                      strcpy(img->colorModel,espacio.c_str());
                      return 0;
               }
               else return 1;
          }
          if (espacioViejo=="HSL")
          {
              if(espacio=="HSV")
              {
                      cvCvtColor(img,img,CV_HLS2BGR);
                      cvCvtColor(img,img,CV_BGR2HSV);
                      strcpy(img->colorModel,espacio.c_str());
                      return 0;
              }
              if(espacio=="RGB")
              {
                      cvCvtColor(img,img,CV_HLS2BGR);
                      strcpy(img->colorModel,espacio.c_str());
                      return 0;
              }
              else return 1;
           }
      }
      return 1;
}

void umbral(IplImage *img, int umbral)
{
    cvThreshold(img,img,umbral,255,CV_THRESH_BINARY);
}


int obtenerUmbralOptimo(IplImage *im)
{
    int mediaBG,mediaFG,umbralSiguiente,umbral,BG,FG,NPF,NPO;
    IplImage *temp;
    CvScalar valor,valor2;

    BG=0;
    FG=0;
    NPF=0;
    NPO=0;

    for(int i = 0; i < im->height; i++)
  for(int j = 0; j < im->width; j++)
  {
     valor2 = cvGet2D(im, i,j);
     if(((i==0) && (j==0))||((i==0)&&(j==(im->width)-1))||((i==(im->height)-1)&&(j==0))||((i==(im->height)-1)&&(j==(im->width)-1)))
     {
                     FG=FG+valor2.val[0];
                     NPO=NPO+1;
             }

     else
     {
                     BG=BG+valor2.val[0];
                     NPF=NPF+1;
             }
  }

    mediaFG= FG/NPO;

    mediaBG= BG/NPF;

    umbralSiguiente=0;
    umbral=(mediaBG+mediaFG)/2;

    while (umbralSiguiente!=umbral)
    {
            umbral=umbralSiguiente;
            temp=cvCloneImage(im);

            cvThreshold(temp,temp,umbral,255,CV_THRESH_BINARY);

            cvNamedWindow( "Res", 1 );
            cvShowImage( "Res", temp );
            cvWaitKey(0);

            BG=0;
            FG=0;
            NPF=0;
            NPO=0;

            for(int i = 0; i < im->height; i++)
            for(int j = 0; j < im->width; j++)
            {
                    valor = cvGet2D(temp, i,j);
                    valor2 = cvGet2D(im, i,j);
                    if(valor.val[0]==0)
                    {
                            FG=FG+valor2.val[0];
                            NPO=NPO+1;
                    }

                    else
                    {
                            BG=BG+valor2.val[0];
                            NPF=NPF+1;
                    }
            }
            if (NPO==0 || NPF==0)
            {
                    if(NPO==0)      mediaFG=0;
                    if(NPF==0)  mediaBG=0;
            }
            else
            {
                    mediaFG= FG/NPO;
                    mediaBG= BG/NPF;
            }
            umbralSiguiente=(mediaBG+mediaFG)/2;
            printf("umbralS = %d\n", umbralSiguiente);
            cvReleaseImage(&temp);
    }

    return umbral;
}
